home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / MNetsrc.hqx / Mac TCP_IP Source v.33 / nrs.c < prev    next >
Text File  |  1989-01-15  |  6KB  |  261 lines
  1. /* This module implements the serial line framing method used by
  2.  * net/rom nodes.  This allows the net/rom software to talk to
  3.  * an actual net/rom over its serial interface, which is useful
  4.  * if we want to do packet switching for multi-line wormholes.
  5.  * Dan Frank, W9NK
  6.  */
  7. #include <stdio.h>
  8. #include "global.h"
  9. #include "mbuf.h"
  10. #include "iface.h"
  11. #include "ax25.h"
  12. #include "nrs.h"
  13. #include "asy.h"
  14. #include "trace.h"
  15. #include "mac.h"
  16.  
  17. int asy_output();
  18.  
  19. /* control structures, sort of overlayed on async control blocks */
  20. struct nrs nrs[ASY_MAX];
  21.  
  22. /* Send a raw net/rom serial frame */
  23. nrs_raw(interface,bp)
  24. struct interface *interface;
  25. struct mbuf *bp;
  26. {
  27.     dump(interface,IF_TRACE_OUT,TRACE_AX25,bp) ;
  28.     
  29.     /* Queue a frame on the output queue and start transmitter */
  30.     nrsq(interface->dev,bp);
  31. }
  32.  
  33. /* Encode a raw packet in net/rom framing, put on link output queue, and kick
  34.  * transmitter
  35.  */
  36. static
  37. nrsq(dev,bp)
  38. int16 dev;        /* Serial line number */
  39. struct mbuf *bp;    /* Buffer to be sent */
  40. {
  41.     register struct nrs *sp;
  42.     struct mbuf *nrs_encode();
  43.  
  44.     if((bp = nrs_encode(bp)) == NULLBUF)
  45.         return;    
  46.  
  47.     sp = &nrs[dev];
  48.     enqueue(&sp->sndq,bp);
  49.     sp->sndcnt++;
  50.     if(sp->tbp == NULLBUF)
  51.         nrasy_start(dev);
  52. }
  53.  
  54. /* Start output, if possible, on asynch device dev */
  55. static
  56. nrasy_start(dev)
  57. int16 dev;
  58. {
  59.     register struct nrs *sp;
  60.  
  61.     if(!stxrdy(dev))
  62.         return;        /* Transmitter not ready */
  63.  
  64.     sp = &nrs[dev];
  65.     if(sp->tbp != NULLBUF){
  66.         /* transmission just completed */
  67.         free_p(sp->tbp);
  68.         sp->tbp = NULLBUF;
  69.     }
  70.     if(sp->sndq == NULLBUF)
  71.         return;    /* No work */
  72.  
  73.     sp->tbp = dequeue(&sp->sndq);
  74.     sp->sndcnt--;
  75.     asy_output(dev,sp->tbp->data,sp->tbp->cnt);
  76. }
  77.  
  78. /* Encode a packet in net/rom serial format */
  79. static
  80. struct mbuf *
  81. nrs_encode(bp)
  82. struct mbuf *bp;
  83. {
  84.     struct mbuf *lbp;    /* Mbuf containing line-ready packet */
  85.     register char *cp;
  86.     char c;
  87.     unsigned char csum = 0 ;
  88.  
  89.     /* Allocate output mbuf that's twice as long as the packet.
  90.      * This is a worst-case guess (consider a packet full of STX's!)
  91.      * Add five bytes for STX, ETX, checksum, and two nulls.
  92.      */
  93.     lbp = alloc_mbuf(2*len_mbuf(bp) + 5);
  94.     if(lbp == NULLBUF){
  95.         /* No space; drop */
  96.         free_p(bp);
  97.         return NULLBUF;
  98.     }
  99.     cp = lbp->data;
  100.  
  101.     *cp++ = STX ;
  102.  
  103.     /* Copy input to output, escaping special characters */
  104.     while(pullup(&bp,&c,1) == 1){
  105.         switch(uchar(c)){
  106.         case STX:
  107.         case ETX:
  108.         case DLE:
  109.             *cp++ = DLE;
  110.             /* notice drop through to default */
  111.         default:
  112.             *cp++ = c;
  113.         }
  114.         csum += uchar(c) ;
  115.     }
  116.     *cp++ = ETX;
  117.     *cp++ = csum ;
  118.     *cp++ = NUL ;
  119.     *cp++ = NUL ;
  120.     
  121.     lbp->cnt = cp - lbp->data;
  122.     return lbp;
  123. }
  124. /* Process incoming bytes in net/rom serial format
  125.  * When a buffer is complete, return it; otherwise NULLBUF
  126.  */
  127. static
  128. struct mbuf *
  129. nrs_decode(dev,c)
  130. int16 dev;    /* net/rom unit number */
  131. char c;        /* Incoming character */
  132. {
  133.     struct mbuf *bp;
  134.     register struct nrs *sp;
  135.  
  136.     sp = &nrs[dev];
  137.     switch(sp->state) {
  138.         case NRS_INTER:
  139.             if (uchar(c) == STX) {    /* look for start of frame */
  140.                 sp->state = NRS_INPACK ;    /* we're in a packet */
  141.                 sp->csum = 0 ;                /* reset checksum */
  142.             }
  143.             return NULLBUF ;
  144.             break ;    /* just for yucks */
  145.         case NRS_CSUM:
  146.             bp = sp->rbp ;
  147.             sp->rbp = NULLBUF ;
  148.             sp->rcnt = 0 ;
  149.             sp->state = NRS_INTER ;    /* go back to inter-packet state */
  150.             if (sp->csum == uchar(c)) {
  151.                 sp->packets++ ;
  152.                 return bp ;
  153.             }
  154.             else {
  155.                 free_p(bp) ;    /* drop packet with bad checksum */
  156.                 sp->errors++ ;    /* increment error count */
  157.                 return NULLBUF ;
  158.             }
  159.             break ;
  160.         case NRS_ESCAPE:
  161.             sp->state = NRS_INPACK ;    /* end of escape */
  162.             break ;            /* this will drop through to char processing */
  163.         case NRS_INPACK:
  164.             switch (uchar(c)) {
  165.                 /* If we see an STX in a packet, assume that previous */
  166.                 /* packet was trashed, and start a new packet */
  167.                 case STX:
  168.                     free_p(sp->rbp) ;
  169.                     sp->rbp = NULLBUF ;
  170.                     sp->rcnt = 0 ;
  171.                     sp->csum = 0 ;
  172.                     sp->errors++ ;
  173.                     return NULLBUF ;
  174.                     break ;
  175.                 case ETX:
  176.                     sp->state = NRS_CSUM ;    /* look for checksum */
  177.                     return NULLBUF ;
  178.                     break ;
  179.                 case DLE:
  180.                     sp->state = NRS_ESCAPE ;
  181.                     return NULLBUF ;
  182.                     break ;
  183.             }
  184.     }
  185.     /* If we get to here, it's with a character that's part of the packet.
  186.      * Make sure there's space for it.
  187.      */
  188.     if(sp->rbp == NULLBUF){
  189.         /* Allocate first mbuf for new packet */
  190.         if((sp->rbp1 = sp->rbp = alloc_mbuf(NRS_ALLOC)) == NULLBUF) {
  191.             sp->state = NRS_INTER ;
  192.             return NULLBUF; /* No memory, drop */
  193.         }
  194.         sp->rcp = sp->rbp->data;
  195.     } else if(sp->rbp1->cnt == NRS_ALLOC){
  196.         /* Current mbuf is full; link in another */
  197.         if((sp->rbp1->next = alloc_mbuf(NRS_ALLOC)) == NULLBUF){
  198.             /* No memory, drop whole thing */
  199.             free_p(sp->rbp);
  200.             sp->rbp = NULLBUF;
  201.             sp->rcnt = 0;
  202.             sp->state = NRS_INTER ;
  203.             return NULLBUF;
  204.         }
  205.         sp->rbp1 = sp->rbp1->next;
  206.         sp->rcp = sp->rbp1->data;
  207.     }
  208.     /* Store the character, increment fragment and total
  209.      * byte counts
  210.      */
  211.     *sp->rcp++ = c;
  212.     sp->rbp1->cnt++;
  213.     sp->rcnt++;
  214.     sp->csum += uchar(c) ;    /* add to checksum */
  215.     return NULLBUF;
  216. }
  217.  
  218. /* Process net/rom serial line I/O */
  219. void
  220. nrs_recv(interface)
  221. struct interface *interface;
  222. {
  223.     char c;
  224.     struct mbuf *bp;
  225.     int16 dev;
  226.     int16 asy_recv();
  227.     int ax_recv() ;
  228.  
  229.     dev = interface->dev;
  230.     /* Process any pending input */
  231.     while(asy_recv(dev,&c,1) != 0)
  232.         if((bp = nrs_decode(dev,c)) != NULLBUF) {
  233.             dump(interface,IF_TRACE_IN,TRACE_AX25,bp) ;
  234.             ax_recv(interface,bp);
  235.         }
  236.  
  237.     /* Kick the transmitter if it's idle */
  238.     if(stxrdy(dev))
  239.         nrasy_start(dev);
  240. }
  241.  
  242. /* donrstat:  display status of active net/rom serial interfaces */
  243. donrstat(argc,argv)
  244. int argc ;
  245. char *argv[] ;
  246. {
  247.     register struct nrs *np ;
  248.     register int i ;
  249.  
  250.     printf("Interface  SndQ  RcvB  NumReceived  CSumErrors\n") ;
  251.  
  252.     for (i = 0, np = nrs ; i < ASY_MAX ; i++, np++)
  253.         if (np->iface != NULLIF)
  254.             printf(" %8s   %3d  %4d   %10lu  %10lu\n",
  255.                     np->iface->name, np->sndcnt, np->rcnt,
  256.                     np->packets, np->errors) ;
  257.  
  258.     return 0 ;
  259. }
  260.  
  261.